Глава 10: Model Context Protocol

Чтобы LLM могли эффективно функционировать в качестве агентов, их возможности должны выходить за рамки мультимодальной генерации. Необходимо взаимодействие с внешней средой, включая доступ к актуальным данным, использование внешнего программного обеспечения и выполнение конкретных операционных задач. Model Context Protocol (MCP) решает эту потребность, предоставляя стандартизированный интерфейс для взаимодействия LLM с внешними ресурсами. Этот протокол служит ключевым механизмом для обеспечения последовательной и предсказуемой интеграции.

Обзор паттерна MCP

Представьте универсальный адаптер, который позволяет любой LLM подключаться к любой внешней системе, базе данных или инструменту без необходимости создания индивидуальной интеграции для каждого из них. По сути, это и есть Model Context Protocol (MCP). Это открытый стандарт, предназначенный для стандартизации взаимодействия LLM, таких как Gemini, модели GPT от OpenAI, Mixtral и Claude, с внешними приложениями, источниками данных и инструментами. Думайте о нем как об универсальном механизме подключения, который упрощает получение контекста LLM, выполнение действий и взаимодействие с различными системами.

MCP работает по архитектуре клиент-сервер. Он определяет, как различные элементы — данные (называемые ресурсами), интерактивные шаблоны (которые по сути являются промптами) и исполняемые функции (известные как инструменты) — предоставляются MCP-сервером. Затем они потребляются MCP-клиентом, которым может быть приложение-хост LLM или сам AI-агент. Такой стандартизированный подход значительно снижает сложность интеграции LLM в разнообразные операционные среды.

Однако MCP представляет собой контракт для "агентного интерфейса", и его эффективность во многом зависит от дизайна базовых API, которые он предоставляет. Существует риск того, что разработчики просто обернут существующие устаревшие API без модификации, что может быть неоптимальным для агента. Например, если API системы тикетов позволяет получать полные детали тикетов только по одному, агенту, которого попросили суммировать высокоприоритетные тикеты, будет медленно и неточно работать с большими объемами. Чтобы быть по-настоящему эффективным, базовый API должен быть улучшен детерминистическими функциями, такими как фильтрация и сортировка, чтобы помочь недетерминистическому агенту работать эффективно. Это подчеркивает, что агенты не заменяют магическим образом детерминистические рабочие процессы; им часто требуется более сильная детерминистическая поддержка для успеха.

Кроме того, MCP может обернуть API, входные или выходные данные которого все еще не являются изначально понятными для агента. API полезен только в том случае, если его формат данных дружественен агенту — гарантия, которую сам MCP не обеспечивает. Например, создание MCP-сервера для хранилища документов, которое возвращает файлы в виде PDF, в основном бесполезно, если потребляющий агент не может разобрать содержимое PDF. Лучшим подходом было бы сначала создать API, который возвращает текстовую версию документа, такую как Markdown, которую агент действительно может прочитать и обработать. Это демонстрирует, что разработчики должны учитывать не только соединение, но и природу обмениваемых данных для обеспечения истинной совместимости.

MCP vs. Tool Function Calling

Model Context Protocol (MCP) и вызов функций инструментов — это различные механизмы, которые позволяют LLM взаимодействовать с внешними возможностями (включая инструменты) и выполнять действия. Хотя оба служат для расширения возможностей LLM за пределы генерации текста, они различаются по подходу и уровню абстракции.

Вызов функций инструментов можно рассматривать как прямой запрос от LLM к конкретному, заранее определенному инструменту или функции. Обратите внимание, что в этом контексте мы используем слова "инструмент" и "функция" взаимозаменяемо. Это взаимодействие характеризуется моделью связи один-к-одному, где LLM форматирует запрос на основе понимания намерения пользователя, требующего внешнего действия. Код приложения затем выполняет этот запрос и возвращает результат LLM. Этот процесс часто является проприетарным и варьируется у разных поставщиков LLM.

В отличие от этого, Model Context Protocol (MCP) работает как стандартизированный интерфейс для LLM для обнаружения, взаимодействия и использования внешних возможностей. Он функционирует как открытый протокол, который облегчает взаимодействие с широким спектром инструментов и систем, стремясь создать экосистему, где любой совместимый инструмент может быть доступен любой совместимой LLM. Это способствует интероперабельности, компонуемости и повторному использованию в различных системах и реализациях. Принимая федеративную модель, мы значительно улучшаем интероперабельность и раскрываем ценность существующих активов. Эта стратегия позволяет нам привести разрозненные и устаревшие сервисы в современную экосистему, просто обернув их в MCP-совместимый интерфейс. Эти сервисы продолжают работать независимо, но теперь могут быть скомпонованы в новые приложения и рабочие процессы, с их сотрудничеством, оркестрируемым LLM. Это способствует гибкости и повторному использованию без необходимости дорогостоящего переписывания основополагающих систем.

Вот разбивка фундаментальных различий между MCP и вызовом функций инструментов:

Функция	Tool Function Calling	Model Context Protocol (MCP)
Стандартизация	Проприетарный и специфичный для поставщика. Формат и реализация различаются у поставщиков LLM.	Открытый, стандартизированный протокол, способствующий интероперабельности между различными LLM и инструментами.
Область применения	Прямой механизм для LLM запросить выполнение конкретной, заранее определенной функции.	Более широкая структура для того, как LLM и внешние инструменты обнаруживают и взаимодействуют друг с другом.
Архитектура	Взаимодействие один-к-одному между LLM и логикой обработки инструментов приложения.	Архитектура клиент-сервер, где приложения с поддержкой LLM (клиенты) могут подключаться и использовать различные MCP-серверы (инструменты).
Обнаружение	LLM явно сообщают, какие инструменты доступны в контексте конкретного разговора.	Обеспечивает динамическое обнаружение доступных инструментов. MCP-клиент может запросить сервер, чтобы увидеть, какие возможности он предлагает.
Повторное использование	Интеграции инструментов часто тесно связаны с конкретным приложением и используемой LLM.	Способствует разработке повторно используемых, автономных "MCP-серверов", которые могут быть доступны любому совместимому приложению.

Думайте о вызове функций инструментов как о предоставлении AI конкретного набора инструментов, изготовленных на заказ, таких как определенный гаечный ключ и отвертка. Это эффективно для мастерской с фиксированным набором задач. MCP (Model Context Protocol), с другой стороны, подобен созданию универсальной, стандартизированной системы розеток. Он не предоставляет инструменты сам по себе, но позволяет любому совместимому инструменту от любого производителя подключиться и работать, обеспечивая динамическую и постоянно расширяющуюся мастерскую.

Короче говоря, вызов функций предоставляет прямой доступ к нескольким конкретным функциям, в то время как MCP является стандартизированной коммуникационной структурой, которая позволяет LLM обнаруживать и использовать обширный спектр внешних ресурсов. Для простых приложений достаточно конкретных инструментов; для сложных, взаимосвязанных AI-систем, которые должны адаптироваться, универсальный стандарт, такой как MCP, необходим.

Дополнительные соображения для MCP

Хотя MCP представляет мощную структуру, тщательная оценка требует рассмотрения нескольких важных аспектов, которые влияют на его пригодность для данного случая использования. Рассмотрим некоторые аспекты более подробно:

• Tool vs. Resource vs. Prompt: Важно понимать конкретные роли этих компонентов. Ресурс — это статические данные (например, PDF-файл, запись базы данных). Инструмент — это исполняемая функция, которая выполняет действие (например, отправка электронной почты, запрос к API). Prompt — это шаблон, который направляет LLM в том, как взаимодействовать с ресурсом или инструментом, обеспечивая структурированность и эффективность взаимодействия.

• Обнаружимость: Ключевым преимуществом MCP является то, что MCP-клиент может динамически запросить сервер, чтобы узнать, какие инструменты и ресурсы он предлагает. Этот механизм обнаружения "точно в срок" мощен для агентов, которым нужно адаптироваться к новым возможностям без повторного развертывания.

• Безопасность: Предоставление инструментов и данных через любой протокол требует надежных мер безопасности. Реализация MCP должна включать аутентификацию и авторизацию для контроля того, какие клиенты могут получить доступ к каким серверам и какие конкретные действия им разрешено выполнять.

• Реализация: Хотя MCP является открытым стандартом, его реализация может быть сложной. Однако поставщики начинают упрощать этот процесс. Например, некоторые поставщики моделей, такие как Anthropic или FastMCP, предлагают SDK, которые абстрагируют большую часть шаблонного кода, упрощая разработчикам создание и подключение MCP-клиентов и серверов.

• Обработка ошибок: Критически важна комплексная стратегия обработки ошибок. Протокол должен определить, как ошибки (например, сбой выполнения инструмента, недоступный сервер, недействительный запрос) передаются обратно LLM, чтобы она могла понять сбой и потенциально попробовать альтернативный подход.

• Локальный vs. удаленный сервер: MCP-серверы могут быть развернуты локально на той же машине, что и агент, или удаленно на другом сервере. Локальный сервер может быть выбран для скорости и безопасности с конфиденциальными данными, в то время как архитектура удаленного сервера позволяет общий, масштабируемый доступ к общим инструментам в организации.

• По требованию vs. пакетная обработка: MCP может поддерживать как интерактивные сессии по требованию, так и крупномасштабную пакетную обработку. Выбор зависит от приложения, от агента реального времени для разговора, нуждающегося в немедленном доступе к инструментам, до конвейера анализа данных, который обрабатывает записи пакетами.

• Механизм транспортировки: Протокол также определяет базовые транспортные слои для коммуникации. Для локальных взаимодействий он использует JSON-RPC через STDIO (стандартный ввод/вывод) для эффективной межпроцессной коммуникации. Для удаленных соединений он использует веб-дружественные протоколы, такие как Streamable HTTP и Server-Sent Events (SSE), чтобы обеспечить постоянную и эффективную коммуникацию клиент-сервер.

Model Context Protocol использует модель клиент-сервер для стандартизации потока информации. Понимание взаимодействия компонентов является ключом к продвинутому агентному поведению MCP:

1. Large Language Model (LLM): Основной интеллект. Он обрабатывает пользовательские запросы, формулирует планы и решает, когда ему нужно получить доступ к внешней информации или выполнить действие.

2. MCP Client: Это приложение или обертка вокруг LLM. Он действует как посредник, переводя намерение LLM в формальный запрос, который соответствует стандарту MCP. Он отвечает за обнаружение, подключение и взаимодействие с MCP-серверами.

3. MCP Server: Это шлюз к внешнему миру. Он предоставляет набор инструментов, ресурсов и промптов любому авторизованному MCP-клиенту. Каждый сервер обычно отвечает за конкретную область, такую как подключение к внутренней базе данных компании, службе электронной почты или публичному API.

4. Дополнительный сторонний сервис: Это представляет фактический внешний инструмент, приложение или источник данных, которым управляет и предоставляет MCP-сервер. Это конечная точка, которая выполняет запрашиваемое действие, такое как запрос к проприетарной базе данных, взаимодействие с SaaS-платформой или вызов публичного API погоды.

Взаимодействие происходит следующим образом:

1. Обнаружение: MCP-клиент от имени LLM запрашивает MCP-сервер, чтобы узнать, какие возможности он предлагает. Сервер отвечает манифестом, перечисляющим его доступные инструменты (например, send_email), ресурсы (например, customer_database) и промпты.

2. Формулирование запроса: LLM определяет, что ей нужно использовать один из обнаруженных инструментов. Например, она решает отправить электронное письмо. Она формулирует запрос, указывая инструмент для использования (send_email) и необходимые параметры (получатель, тема, тело).

3. Коммуникация клиента: MCP-клиент берет сформулированный LLM запрос и отправляет его как стандартизированный вызов соответствующему MCP-серверу.

4. Выполнение сервера: MCP-сервер получает запрос. Он аутентифицирует клиента, проверяет запрос, а затем выполняет указанное действие, взаимодействуя с базовым программным обеспечением (например, вызывая функцию send() API электронной почты).

5. Ответ и обновление контекста: После выполнения MCP-сервер отправляет стандартизированный ответ обратно MCP-клиенту. Этот ответ указывает, было ли действие успешным, и включает любой соответствующий вывод (например, ID подтверждения для отправленного электронного письма). Клиент затем передает этот результат обратно LLM, обновляя ее контекст и позволяя ей продолжить со следующим шагом своей задачи.

Практические применения и случаи использования

MCP значительно расширяет возможности AI/LLM, делая их более универсальными и мощными. Вот девять ключевых случаев использования:

• Интеграция с базами данных: MCP позволяет LLM и агентам беспрепятственно получать доступ и взаимодействовать со структурированными данными в базах данных. Например, используя MCP Toolbox для баз данных, агент может запрашивать наборы данных Google BigQuery для получения информации в реальном времени, генерировать отчеты или обновлять записи, все это управляется командами на естественном языке.

• Оркестрация генеративных медиа: MCP позволяет агентам интегрироваться с продвинутыми сервисами генеративных медиа. Через MCP Tools для сервисов Genmedia агент может оркестрировать рабочие процессы, включающие Google Imagen для генерации изображений, Google Veo для создания видео, Google Chirp 3 HD для реалистичных голосов или Google Lyria для композиции музыки, позволяя динамическое создание контента в AI-приложениях.

• Взаимодействие с внешними API: MCP предоставляет стандартизированный способ для LLM вызывать и получать ответы от любого внешнего API. Это означает, что агент может получать данные о погоде в реальном времени, извлекать цены акций, отправлять электронные письма или взаимодействовать с CRM-системами, расширяя свои возможности далеко за пределы основной языковой модели.

• Извлечение информации на основе рассуждений: Используя сильные навыки рассуждения LLM, MCP облегчает эффективное, зависимое от запроса извлечение информации, которое превосходит обычные системы поиска и извлечения. Вместо традиционного инструмента поиска, возвращающего весь документ, агент может анализировать текст и извлекать точную клаузулу, цифру или утверждение, которое прямо отвечает на сложный вопрос пользователя.

• Разработка пользовательских инструментов: Разработчики могут создавать пользовательские инструменты и предоставлять их через MCP-сервер (например, используя FastMCP). Это позволяет специализированным внутренним функциям или проприетарным системам быть доступными для LLM и других агентов в стандартизированном, легко потребляемом формате, без необходимости напрямую изменять LLM.

• Стандартизированная коммуникация LLM-к-приложению: MCP обеспечивает последовательный коммуникационный слой между LLM и приложениями, с которыми они взаимодействуют. Это снижает накладные расходы на интеграцию, способствует интероперабельности между различными поставщиками LLM и хост-приложениями, и упрощает разработку сложных агентных систем.

• Оркестрация сложных рабочих процессов: Объединяя различные инструменты и источники данных, предоставляемые через MCP, агенты могут оркестрировать высоко сложные, многошаговые рабочие процессы. Агент мог бы, например, получить данные о клиентах из базы данных, сгенерировать персонализированное маркетинговое изображение, составить индивидуальное электронное письмо, а затем отправить его, все это взаимодействуя с различными MCP-сервисами.

• Управление устройствами IoT: MCP может облегчить взаимодействие LLM с устройствами Интернета вещей (IoT). Агент мог бы использовать MCP для отправки команд умным домашним приборам, промышленным датчикам или робототехнике, обеспечивая управление и автоматизацию физических систем на естественном языке.

• Автоматизация финансовых услуг: В финансовых услугах MCP мог бы позволить LLM взаимодействовать с различными источниками финансовых данных, торговыми платформами или системами соответствия. Агент мог бы анализировать рыночные данные, выполнять сделки, генерировать персонализированные финансовые советы или автоматизировать регулятивную отчетность, все это при поддержании безопасной и стандартизированной коммуникации.

Короче говоря, Model Context Protocol (MCP) позволяет агентам получать доступ к информации в реальном времени из баз данных, API и веб-ресурсов. Он также позволяет агентам выполнять действия, такие как отправка электронных писем, обновление записей, управление устройствами и выполнение сложных задач путем интеграции и обработки данных из различных источников. Дополнительно, MCP поддерживает инструменты генерации медиа для AI-приложений.

Практический пример кода с ADK

Этот раздел описывает, как подключиться к локальному MCP-серверу, который предоставляет операции файловой системы, позволяя ADK-агенту взаимодействовать с локальной файловой системой.

Настройка агента с MCPToolset

Для настройки агента для взаимодействия с файловой системой необходимо создать файл agent.py (например, в ./adk_agent_samples/mcp_agent/agent.py). MCPToolset создается в списке tools объекта LlmAgent. Крайне важно заменить "/path/to/your/folder" в списке args на абсолютный путь к директории в локальной системе, к которой MCP-сервер может получить доступ. Эта директория будет корневой для операций файловой системы, выполняемых агентом.

import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

# Создаем надежный абсолютный путь к папке с именем 'mcp_managed_files'
# в той же директории, что и этот скрипт агента.
# Это обеспечивает работу агента из коробки для демонстрации.
# Для продакшена вы бы указали это на более постоянное и безопасное место.
TARGET_FOLDER_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mcp_managed_files")

# Убедимся, что целевая директория существует до того, как агент в ней нуждается.
os.makedirs(TARGET_FOLDER_PATH, exist_ok=True)

root_agent = LlmAgent(
    model='gemini-2.0-flash',
    name='filesystem_assistant_agent',
    instruction=(
        'Помогайте пользователю управлять их файлами. Вы можете перечислять файлы, читать файлы и записывать файлы. '
        f'Вы работаете в следующей директории: {TARGET_FOLDER_PATH}'
    ),
    tools=[
        MCPToolset(
            connection_params=StdioServerParameters(
                command='npx',
                args=[
                    "-y",  # Аргумент для npx для автоподтверждения установки
                    "@modelcontextprotocol/server-filesystem",
                    # Это ДОЛЖЕН быть абсолютный путь к папке.
                    TARGET_FOLDER_PATH,
                ],
            ),
            # Опционально: Вы можете отфильтровать, какие инструменты от MCP-сервера предоставляются.
            # Например, чтобы разрешить только чтение:
            # tool_filter=['list_directory', 'read_file']
        )
    ],
)

npx (Node Package Execute), входящий в состав npm (Node Package Manager) версий 5.2.0 и позднее, это утилита, которая позволяет прямое выполнение Node.js пакетов из реестра npm. Это устраняет необходимость глобальной установки. По сути, npx служит как исполнитель npm-пакетов, и он обычно используется для запуска многих общественных MCP-серверов, которые распространяются как Node.js пакеты.

Создание файла init.py необходимо для обеспечения того, чтобы файл agent.py был распознан как часть обнаруживаемого Python-пакета для Agent Development Kit (ADK). Этот файл должен находиться в той же директории, что и agent.py.

# ./adk_agent_samples/mcp_agent/__init__.py
from . import agent

Конечно, другие поддерживаемые команды доступны для использования. Например, подключение к python3 может быть достигнуто следующим образом:

connection_params = StdioConnectionParams(
    server_params={
        "command": "python3",
        "args": ["./agent/mcp_server.py"],
        "env": {
            "SERVICE_ACCOUNT_PATH": SERVICE_ACCOUNT_PATH,
            "DRIVE_FOLDER_ID": DRIVE_FOLDER_ID
        }
    }
)

UVX, в контексте Python, относится к инструменту командной строки, который использует uv для выполнения команд во временной, изолированной Python-среде. По сути, он позволяет вам запускать Python-инструменты и пакеты без необходимости устанавливать их глобально или в среде вашего проекта. Вы можете запустить его через MCP-сервер.

connection_params = StdioConnectionParams(
    server_params={
        "command": "uvx",
        "args": ["mcp-google-sheets@latest"],
        "env": {
            "SERVICE_ACCOUNT_PATH": SERVICE_ACCOUNT_PATH,
            "DRIVE_FOLDER_ID": DRIVE_FOLDER_ID
        }
    }
)

После создания MCP-сервера следующим шагом является подключение к нему.

Подключение MCP-сервера с ADK Web

Для начала выполните 'adk web'. Перейдите к родительской директории mcp_agent (например, adk_agent_samples) в вашем терминале и выполните:

cd ./adk_agent_samples # Или ваша эквивалентная родительская директория
adk web

После загрузки ADK Web UI в вашем браузере выберите filesystem_assistant_agent из меню агентов. Затем экспериментируйте с промптами, такими как:

• "Покажите мне содержимое этой папки."
• "Прочитайте файл sample.txt." (Это предполагает, что sample.txt находится в TARGET_FOLDER_PATH.)
• "Что в another_file.md?"

Создание MCP-сервера с FastMCP

FastMCP — это высокоуровневая Python-структура, предназначенная для упрощения разработки MCP-серверов. Она предоставляет слой абстракции, который упрощает сложности протокола, позволяя разработчикам сосредоточиться на основной логике.

Библиотека позволяет быстрое определение инструментов, ресурсов и промптов, используя простые Python-декораторы. Значительным преимуществом является ее автоматическая генерация схем, которая интеллектуально интерпретирует подписи Python-функций, подсказки типов и строки документации для построения необходимых спецификаций интерфейса AI-модели. Эта автоматизация минимизирует ручную настройку и уменьшает человеческие ошибки.

За пределами базового создания инструментов, FastMCP облегчает продвинутые архитектурные паттерны, такие как композиция серверов и проксирование. Это позволяет модульную разработку сложных, многокомпонентных систем и беспрепятственную интеграцию существующих сервисов в AI-доступную структуру. Дополнительно, FastMCP включает оптимизации для эффективных, распределенных и масштабируемых AI-управляемых приложений.

Настройка сервера с FastMCP

Для иллюстрации рассмотрим базовый инструмент "greet", предоставляемый сервером. ADK-агенты и другие MCP-клиенты могут взаимодействовать с этим инструментом через HTTP, как только он станет активным.

# fastmcp_server.py
# Этот скрипт демонстрирует, как создать простой MCP-сервер, используя FastMCP.
# Он предоставляет единственный инструмент, который генерирует приветствие.

# 1. Убедитесь, что у вас установлен FastMCP:
# pip install fastmcp
from fastmcp import FastMCP, Client

# Инициализируем FastMCP-сервер.
mcp_server = FastMCP()

# Определяем простую функцию инструмента.
# Декоратор `@mcp_server.tool` регистрирует эту Python-функцию как MCP-инструмент.
# Строка документации становится описанием инструмента для LLM.
@mcp_server.tool
def greet(name: str) -> str:
    """
    Генерирует персонализированное приветствие.

    Args:
        name: Имя человека для приветствия.

    Returns:
        Строка приветствия.
    """
    return f"Привет, {name}! Приятно познакомиться."

# Или если вы хотите запустить его из скрипта:
if __name__ == "__main__":
    mcp_server.run(
        transport="http",
        host="127.0.0.1",
        port=8000
    )

Этот Python-скрипт определяет единственную функцию под названием greet, которая принимает имя человека и возвращает персонализированное приветствие. Декоратор @tool() над этой функцией автоматически регистрирует ее как инструмент, который AI или другая программа может использовать. Строка документации функции и подсказки типов используются FastMCP для сообщения агенту, как работает инструмент, какие входные данные ему нужны и что он вернет.

Когда скрипт выполняется, он запускает FastMCP-сервер, который слушает запросы на localhost:8000. Это делает функцию greet доступной как сетевой сервис. Агент затем может быть настроен для подключения к этому серверу и использования инструмента greet для генерации приветствий как части более крупной задачи. Сервер работает непрерывно, пока не будет остановлен вручную.

Потребление FastMCP-сервера с ADK-агентом

ADK-агент может быть настроен как MCP-клиент для использования работающего FastMCP-сервера. Это требует настройки HttpServerParameters с сетевым адресом FastMCP-сервера, который обычно http://localhost:8000.

Параметр tool_filter может быть включен для ограничения использования инструментов агентом конкретными инструментами, предлагаемыми сервером, такими как 'greet'. Когда агенту дается запрос типа "Поприветствуйте Джона Доу", встроенная LLM агента идентифицирует инструмент 'greet', доступный через MCP, вызывает его с аргументом "Джон Доу" и возвращает ответ сервера. Этот процесс демонстрирует интеграцию пользовательских инструментов, предоставляемых через MCP, с ADK-агентом.

Для установления этой конфигурации требуется файл агента (например, agent.py, расположенный в ./adk_agent_samples/fastmcp_client_agent/). Этот файл создаст ADK-агента и использует HttpServerParameters для установления соединения с работающим FastMCP-сервером.

# ./adk_agent_samples/fastmcp_client_agent/agent.py
import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, HttpServerParameters

# Определяем адрес FastMCP-сервера.
# Убедитесь, что ваш fastmcp_server.py (определенный ранее) работает на этом порту.
FASTMCP_SERVER_URL = "`http://localhost:8000`"

root_agent = LlmAgent(
    model='gemini-2.0-flash',  # Или ваша предпочитаемая модель
    name='fastmcp_greeter_agent',
    instruction='Вы дружелюбный ассистент, который может приветствовать людей по имени. Используйте инструмент "greet".',
    tools=[
        MCPToolset(
            connection_params=HttpServerParameters(
                url=FASTMCP_SERVER_URL,
            ),
            # Опционально: Отфильтровать, какие инструменты от MCP-сервера предоставляются
            # Для этого примера мы ожидаем только 'greet'
            tool_filter=['greet']
        )
    ],
)

Скрипт определяет агента с именем fastmcp_greeter_agent, который использует языковую модель Gemini. Ему дается конкретная инструкция действовать как дружелюбный ассистент, цель которого — приветствовать людей. Критически важно, что код оснащает этого агента инструментом для выполнения его задачи. Он настраивает MCPToolset для подключения к отдельному серверу, работающему на localhost:8000, который ожидается быть FastMCP-сервером из предыдущего примера. Агенту конкретно предоставляется доступ к инструменту greet, размещенному на этом сервере. По сути, этот код настраивает клиентскую сторону системы, создавая интеллектуального агента, который понимает, что его цель — приветствовать людей, и знает точно, какой внешний инструмент использовать для этого.

Создание файла init.py в директории fastmcp_client_agent необходимо. Это обеспечивает распознавание агента как обнаруживаемого Python-пакета для ADK.

Для начала откройте новый терминал и запустите python fastmcp_server.py для запуска FastMCP-сервера. Затем перейдите к родительской директории fastmcp_client_agent (например, adk_agent_samples) в вашем терминале и выполните adk web. После загрузки ADK Web UI в вашем браузере выберите fastmcp_greeter_agent из меню агентов. Затем вы можете протестировать его, введя промпт типа "Поприветствуйте Джона Доу." Агент будет использовать инструмент greet на вашем FastMCP-сервере для создания ответа.

В двух словах

Что: Чтобы функционировать как эффективные агенты, LLM должны выйти за рамки простой генерации текста. Им требуется способность взаимодействовать с внешней средой для доступа к актуальным данным и использования внешнего программного обеспечения. Без стандартизированного метода коммуникации каждая интеграция между LLM и внешним инструментом или источником данных становится индивидуальной, сложной и неповторно используемой задачей. Такой ad-hoc подход препятствует масштабируемости и делает построение сложных, взаимосвязанных AI-систем трудным и неэффективным.

Почему: Model Context Protocol (MCP) предлагает стандартизированное решение, действуя как универсальный интерфейс между LLM и внешними системами. Он устанавливает открытый, стандартизированный протокол, который определяет, как внешние возможности обнаруживаются и используются. Работая по модели клиент-сервер, MCP позволяет серверам предоставлять инструменты, ресурсы данных и интерактивные промпты любому совместимому клиенту. Приложения с поддержкой LLM действуют как эти клиенты, динамически обнаруживая и взаимодействуя с доступными ресурсами предсказуемым образом. Такой стандартизированный подход способствует созданию экосистемы интероперабельных и повторно используемых компонентов, значительно упрощая разработку сложных агентных рабочих процессов.

Практическое правило: Используйте Model Context Protocol (MCP) при построении сложных, масштабируемых или корпоративных агентных систем, которые должны взаимодействовать с разнообразным и развивающимся набором внешних инструментов, источников данных и API. Он идеален, когда интероперабельность между различными LLM и инструментами является приоритетом, и когда агентам требуется способность динамически обнаруживать новые возможности без повторного развертывания. Для более простых приложений с фиксированным и ограниченным количеством предопределенных функций может быть достаточно прямого вызова функций инструментов.

Визуальное резюме

Рис.1: Model Context Protocol

Ключевые выводы

Это ключевые выводы:

• Model Context Protocol (MCP) — это открытый стандарт, облегчающий стандартизированную коммуникацию между LLM и внешними приложениями, источниками данных и инструментами.

• Он использует архитектуру клиент-сервер, определяя методы для предоставления и потребления ресурсов, промптов и инструментов.

• Agent Development Kit (ADK) поддерживает как использование существующих MCP-серверов, так и предоставление ADK-инструментов через MCP-сервер.

• FastMCP упрощает разработку и управление MCP-серверами, особенно для предоставления инструментов, реализованных на Python.

• MCP Tools для сервисов Genmedia позволяет агентам интегрироваться с возможностями генеративных медиа Google Cloud (Imagen, Veo, Chirp 3 HD, Lyria).

• MCP позволяет LLM и агентам взаимодействовать с реальными системами, получать доступ к динамической информации и выполнять действия за пределами генерации текста.

Заключение

Model Context Protocol (MCP) — это открытый стандарт, который облегчает коммуникацию между Large Language Models (LLM) и внешними системами. Он использует архитектуру клиент-сервер, позволяя LLM получать доступ к ресурсам, использовать промпты и выполнять действия через стандартизированные инструменты. MCP позволяет LLM взаимодействовать с базами данных, управлять рабочими процессами генеративных медиа, контролировать устройства IoT и автоматизировать финансовые услуги. Практические примеры демонстрируют настройку агентов для взаимодействия с MCP-серверами, включая серверы файловой системы и серверы, построенные с FastMCP, иллюстрируя его интеграцию с Agent Development Kit (ADK). MCP является ключевым компонентом для разработки интерактивных AI-агентов, которые выходят за рамки базовых языковых возможностей.

Ссылки

1. Model Context Protocol (MCP) Documentation

2. FastMCP Documentation

3. MCP Tools for Genmedia Services

4. MCP Toolbox for Databases Documentation

---

Навигация

Назад: Глава 9. Обучение и адаптация
Вперед: Глава 11. Постановка целей и мониторинг